Step 1. Open the data file and study the general information¶
In [1]:
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.offline as py
import plotly.graph_objs as go
from plotly.offline import iplot
from plotly.graph_objs import Scatter
import seaborn as sns
import squarify
import math
import numpy as np
from scipy import stats as st
import numpy as np
pd.options.display.max_columns = None
df_games = pd.read_csv('games.csv')
change all columns names to lowercase¶
In [2]:
df_games.columns = df_games.columns.str.lower()
df_games.head()
Out[2]:
In [ ]:
In [3]:
df_games.describe()
Out[3]:
In [4]:
df_games.describe(include = ['object'])
Out[4]:
In [5]:
df_games.info()
In [6]:
df_games.shape
Out[6]:
In [7]:
#how many NULL are ther in df_games
df_games.isnull().sum()
Out[7]:
Step 2. Prepare the data¶
name:¶
In [8]:
df_games[df_games['name'].isna()]
Out[8]:
In [9]:
df_games['name'] = df_games['name'].fillna('missing name')
In [10]:
df_games['genre'] = df_games['genre'].fillna('missing genre')
In [ ]:
In [ ]:
year_of_release:¶
In [11]:
df_games[df_games['year_of_release'].isna()].head()
Out[11]:
For games with missing year of release, if the year appear in the name, use it.¶
In [12]:
def year_of_release(row):
name = row['name']
for year in range(1980, 2017):
if str(year) in name:
return year
return None
df_games['year_of_release'] = df_games['year_of_release'].fillna(df_games.apply(year_of_release, axis = 1))
find the year platformed first appered¶
In [13]:
platform_year_of_release_df = df_games.pivot_table(index = 'platform', values = 'year_of_release', aggfunc = 'min').reset_index()
platform_year_of_release_df.head()
Out[13]:
For games with missing year of release, the first year of the platform will be release year¶
In [14]:
def platform_release(row):
platform = row['platform']
year_df = platform_year_of_release_df[platform_year_of_release_df['platform'] == platform]
year = year_df['year_of_release'].values.tolist()
return year[0]
df_games['year_of_release'] = df_games['year_of_release'].fillna(df_games.apply(platform_release, axis = 1))
change year_of_release to int¶
In [15]:
df_games.year_of_release = df_games.year_of_release.astype(int)
critic_score:¶
In [16]:
df_games['critic_score'].fillna(0, inplace=True)
In [17]:
genre_year_of_release_critic_score_df = df_games[df_games['critic_score'] != 0].pivot_table(index = ('genre', 'year_of_release'), values = 'critic_score', aggfunc = 'mean' ).reset_index()
genre_year_of_release_critic_score_df['critic_score_mean'] = genre_year_of_release_critic_score_df['critic_score']
del genre_year_of_release_critic_score_df['critic_score']
genre_year_of_release_critic_score_df.head()
Out[17]:
In [18]:
def critic_score_update(row):
critic_score = row['critic_score']
genre = row['genre']
year_of_release = row['year_of_release']
if critic_score == 0:
critic_score_df = genre_year_of_release_critic_score_df[(genre_year_of_release_critic_score_df['genre'] == genre) & (genre_year_of_release_critic_score_df['year_of_release'] == year_of_release)]['critic_score_mean']
if critic_score_df.empty:
return 0
critic_score_mean = critic_score_df.values.tolist()
return critic_score_mean[0]
return critic_score
df_games['critic_score'] = df_games.apply(critic_score_update, axis = 1)
user_score:¶
In [19]:
df_games['user_score'].fillna(100, inplace=True)
In [20]:
def user_score_update(row):
user_score = row['user_score']
if user_score == 'tbd':
return 100
return user_score
df_games['user_score'] = df_games.apply(user_score_update, axis = 1)
change user_score to float¶
In [21]:
df_games.user_score = df_games.user_score.astype(float)
In [22]:
genre_year_of_release_user_score_df = df_games[df_games['user_score'] != 100].pivot_table(index = ('genre', 'year_of_release'), values = 'user_score', aggfunc = 'mean' ).reset_index()
genre_year_of_release_user_score_df['user_score_mean'] = genre_year_of_release_user_score_df['user_score']
del genre_year_of_release_user_score_df['user_score']
genre_year_of_release_user_score_df.head()
Out[22]:
In [23]:
def user_score_update(row):
user_score = row['user_score']
genre = row['genre']
year_of_release = row['year_of_release']
if user_score == 100:
user_score_df = genre_year_of_release_user_score_df[(genre_year_of_release_user_score_df['genre'] == genre) & (genre_year_of_release_user_score_df['year_of_release'] == year_of_release)]['user_score_mean']
if user_score_df.empty:
return 0
user_score_mean = user_score_df.values.tolist()
return user_score_mean[0]
return user_score
df_games['user_score'] = df_games.apply(user_score_update, axis = 1)
rating:¶
rating by year and genre¶
In [24]:
df_games.pivot_table(index = ('year_of_release', 'genre'), columns = 'rating', values = 'name', aggfunc = 'count' ).reset_index().head()
Out[24]:
In [25]:
df_games['rating'].fillna('mis', inplace=True)
df_games.describe()
Out[25]:
In [26]:
df_games.describe(include = ['object'])
Out[26]:
how many NULL are there in df_games¶
In [27]:
df_games.isnull().sum()
Out[27]:
there are no more null values in the data¶
In [ ]:
Why do you think the values are missing? Give possible reasons.¶
Calculate the total sales (the sum of sales in all regions) for each game and put these values in a separate column.¶
In [28]:
df_games['total_sales'] = df_games[['na_sales', 'eu_sales', 'jp_sales', 'other_sales']].sum(axis = 1)
In [29]:
df_games[['name', 'total_sales']].head()
Out[29]:
Step 3. Analyze the data¶
Look at how many games were released in different years. Is the data for every period significant?¶
create a df with amount of games & Year_of_Release¶
In [30]:
amount_year_of_release_df = df_games[['year_of_release','name',]].groupby('year_of_release').count().sort_values(by = 'year_of_release').reset_index()
In [31]:
amount_year_of_release_df.head()
Out[31]:
create lollypop graphs¶
In [32]:
fig, ax = plt.subplots(figsize = (17, 10))
ax.vlines(x = amount_year_of_release_df.year_of_release, ymin = 0, ymax = amount_year_of_release_df.name, color = 'purple', alpha = 0.7, linewidth = 2)
ax.scatter(x = amount_year_of_release_df.year_of_release, y = amount_year_of_release_df.name, s = 75, color = 'black', alpha = 0.7)
#set title
ax.set_title('Lollipop Chart for Released Games', fontdict = {'size': 15})
#set lable for Y
ax.set_ylabel('Number of Games')
#set ticks
ax.set_xticks(amount_year_of_release_df.year_of_release)
ax.set_xticklabels(amount_year_of_release_df.year_of_release, rotation = 90, fontdict = {'horizontalalignment' : 'center', 'size': 12})
#add text above the dot
for row in amount_year_of_release_df.itertuples():
ax.text(row.year_of_release, row.name + 30, s = round(row.name, 2))
The data before 1994 is insignificant. There were very few games published.¶
The gaming world has change dramatically from year to year. I doubt any information older than 10 years is relevant.¶
Because there was a boom in games releases in 2002 I think that only data from 2012 will be relevant to a 2017 camping.¶
Look at how sales varied from platform to platform.¶
Choose the platforms with the greatest total sales and build a distribution based on data for each year.¶
Find platforms that used to be popular but now have zero sales.¶
How long does it generally take for new platforms to appear and old ones to fade?¶
In [33]:
#find total sales by playform
sales_df = df_games[['platform', 'total_sales']].groupby('platform').sum().sort_values('total_sales').reset_index()
In [34]:
sales_df.head()
Out[34]:
In [35]:
sales_df['sales_z'] = (sales_df['total_sales'] - sales_df['total_sales'].mean()) / sales_df['total_sales'].std()
In [36]:
sales_df.head()
Out[36]:
Divergent graph:¶
In [37]:
#for sales_z above 0, paint green.
#for sales_z below 0, paint red.
sales_df['colors'] = ['red' if x < 0 else 'green' for x in sales_df['sales_z']]
sales_df.head()
Out[37]:
In [38]:
sales_df.tail()
Out[38]:
In [39]:
plt.figure(figsize = (14, 10))
#create a graph with horizontal lines
plt.hlines(y =sales_df.platform, xmin = 0, xmax = sales_df.sales_z, color = sales_df.colors, alpha = 0.4, linewidth = 10)
Out[39]:
In [40]:
df_tree = sales_df[sales_df['total_sales'] >= 1]
In [41]:
sizes = df_tree['total_sales'].values.tolist()
In [42]:
labels = df_tree.apply(lambda x: str(x[0]) + '\n' + '$' + str(round(x[1])), axis = 1)
Look at how sales varied from platform to platform¶
This is the distribution of sales.¶
In [43]:
plt.figure(figsize = (15, 9))
squarify.plot(sizes = sizes, label = labels, alpha = 0.5)
Out[43]:
Choose the platforms with the greatest total sales and build a distribution based on data for each year.¶
In [44]:
#I will choose platforms that have total sales of over 700 million dollasr
big_salses_list = sales_df[sales_df['total_sales'] > 700]['platform'].values.tolist()
In [45]:
big_salses_df = df_games[df_games['platform'].isin(big_salses_list)][['platform', 'year_of_release', 'total_sales']]
big_salses_df.head()
Out[45]:
In [46]:
big_salses_df.shape
Out[46]:
In [47]:
sales_by_year_df = big_salses_df.pivot_table(index = ('platform', 'year_of_release'), values = 'total_sales', aggfunc = 'sum').sort_values('year_of_release').reset_index()
sales_by_year_df.head()
Out[47]:
In [48]:
sales_by_year_df.shape
Out[48]:
In [49]:
year_min = sales_by_year_df.year_of_release.min()
year_max = sales_by_year_df.year_of_release.max()
for year in range(year_min, year_max + 1):
print('Distribution for year:', year)
sizes = sales_by_year_df[sales_by_year_df['year_of_release'] == year]['total_sales'].values.tolist()
labels = sales_by_year_df[sales_by_year_df['year_of_release'] == year].apply(lambda x: str(x[0]) + '\n' + '$' + str(round(x[2])), axis = 1)
plt.figure(figsize = (10, 6))
squarify.plot(sizes = sizes, label = labels, alpha = 0.5)
plt.show()
In [50]:
#will show from 1994
sales_by_year_df = sales_by_year_df[sales_by_year_df['year_of_release'] >= 1994]
fig, ax = plt.subplots(figsize = (15, 10))
colors = ['red', 'gold', 'black', 'violet', 'cyan', 'peru']
i = 0
for platform in big_salses_list:
df = sales_by_year_df[(sales_by_year_df['platform'] == platform) ]
df.plot(kind = 'line', x = 'year_of_release', y = 'total_sales', color = colors[i], ax = ax, label = platform)
i += 1
ax.grid(axis = 'x')
#set ticks
ax.set_xticks(sales_by_year_df.year_of_release)
ax.set_xticklabels(sales_by_year_df.year_of_release, rotation = 90, fontdict = {'horizontalalignment' : 'center', 'size': 12})
plt.show()
In [51]:
list_platform = df_games[df_games['year_of_release'] > 2002]['platform'].unique()
In [52]:
#platform from the last 10 years.
sales_by_year_df_10 = df_games.pivot_table(index = ('platform', 'year_of_release'), values = 'total_sales', aggfunc = 'sum').sort_values('year_of_release').reset_index()
sales_by_year_df_10 = sales_by_year_df_10[sales_by_year_df_10['year_of_release'] >= 2002]
fig, ax = plt.subplots(figsize = (15, 10))
colors = ['red', 'gold', 'black', 'violet', 'cyan', 'peru', 'gray', 'tan', 'darkgreen', 'blue', 'orange', 'fuchsia', 'y', 'aqua', 'brown', 'tomato', 'orchid']
i = 0
for platform in list_platform:
df_10 = sales_by_year_df_10[(sales_by_year_df_10['platform'] == platform)]
df_10.plot(kind = 'line', x = 'year_of_release', y = 'total_sales', color = colors[i], ax = ax, label = platform)
i += 1
ax.grid(axis = 'x')
#set ticks
ax.set_xticks(sales_by_year_df_10.year_of_release)
ax.set_xticklabels(sales_by_year_df_10.year_of_release, rotation = 90, fontdict = {'horizontalalignment' : 'center', 'size': 12})
plt.show()
The relatively new platforms XOne, PS4 are also passed their pick and declining.¶
In [ ]:
In [53]:
sales_by_year_df_10.head()
Out[53]:
In [ ]:
It seems that a platform will almost vanish after 8 years, and completely vanish after 10¶
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In order to look at the change, will calculate the difference in sales between years.¶
In [54]:
#find total sale by year for each platform
df_games_total_sales = df_games[df_games['year_of_release'] >= 2000 ].pivot_table(index = 'year_of_release', columns = 'platform', values = 'total_sales', aggfunc = 'sum', fill_value = 0)
df_games_total_sales.tail()
Out[54]:
In [55]:
df_games_total_sales.shift(+1).tail()
Out[55]:
In [56]:
dynamics_df = df_games_total_sales - df_games_total_sales.shift(+1)
In [57]:
dynamics_df.tail()
Out[57]:
Visualize the change in sales for each platform¶
In [ ]:
In [58]:
plt.figure(figsize = (13, 9))
sns.heatmap(dynamics_df.T, cmap = 'RdBu_r') #use RED & BLUE colors
Out[58]:
In [ ]:
In [ ]:
In [59]:
grouped_df = df_games[df_games['year_of_release'] > 2000].groupby(['platform', 'year_of_release'])['total_sales'].sum().reset_index()
In [60]:
grouped_df.head()
Out[60]:
a list of the platforms ordered from least profitable to most profitable.¶
In [61]:
ordered_df = grouped_df.groupby(['platform'])['total_sales'].sum().sort_values().reset_index()['platform']
In [62]:
plt.figure(figsize = (13, 10))
sns.boxplot(x = 'platform', y = 'total_sales', data = grouped_df, order = ordered_df)
Out[62]:
over the years the leading platforms were showing better mean then the rest of the platforms.¶
In [ ]:
Are the differences in sales significant?¶
The differences are very significant.¶
At the top of popularity sales have reached 200 million a year in sales for a single platform. And many have sold in more them 100 million.¶
But in the last year, the leading platforms: PS4, XOne, 3DS, PC . have bearlu touched the 50 million mark, or less.¶
In [ ]:
What about average sales on various platforms? Describe your findings.¶
All of the platforms are declining in sales.¶
Historically, the most popular platforms had a mean that ranged between 70 to 100 million. Except WII, which was huge in sales, but its mean was about 50 million.¶
Then there are the next stage in popularity, with a mean of between 20 to 40 million.¶
In [ ]:
In [63]:
ps2_df = df_games[df_games['platform'] == 'PS2'][['name', 'year_of_release', 'genre', 'total_sales', 'critic_score', 'user_score']]
ps2_df.head()
Out[63]:
In [64]:
#total sales by year
ps2_df.pivot_table(index = 'year_of_release', values = 'total_sales', aggfunc = 'sum')
Out[64]:
In [65]:
#mean critic_score by year
ps2_df.pivot_table(index = 'year_of_release', values = 'critic_score', aggfunc = 'mean')
Out[65]:
In [66]:
ps2_values_df = ps2_df.pivot_table(index = 'year_of_release', values = ('total_sales', 'critic_score', 'user_score'), aggfunc = ('sum', 'mean')).reset_index()
In [67]:
del ps2_values_df[('critic_score', 'sum')]
del ps2_values_df[('total_sales', 'mean')]
del ps2_values_df[('user_score', 'sum')]
In [68]:
ps2_values_df.columns = ['year_of_release', 'critic_score_mean', 'total_sales_sum', 'user_score_mean']
summary of values for PS2 platform¶
In [69]:
ps2_values_df
Out[69]:
In [ ]:
Total sales by critic score for PS2¶
In [ ]:
In [70]:
fig, ax = plt.subplots(figsize = (10, 5))
#ax.vlines(x = amount_year_of_release_df.year_of_release, ymin = 0, ymax = amount_year_of_release_df.name, color = 'purple', alpha = 0.7, linewidth = 2)
ax.scatter(x = ps2_values_df.total_sales_sum, y = ps2_values_df.critic_score_mean, s = 75, color = 'black', alpha = 0.7)
#set title
ax.set_title('Total sales by critic score', fontdict = {'size': 15})
#set lable for Y
ax.set_ylabel('critic score mean')
Out[70]:
In [ ]:
Total sales by user score for PS2¶
In [71]:
fig, ax = plt.subplots(figsize = (10, 5))
#ax.vlines(x = amount_year_of_release_df.year_of_release, ymin = 0, ymax = amount_year_of_release_df.name, color = 'purple', alpha = 0.7, linewidth = 2)
ax.scatter(x = ps2_values_df.total_sales_sum, y = ps2_values_df.user_score_mean, s = 75, color = 'black', alpha = 0.7)
#set title
ax.set_title('Total sales by user score', fontdict = {'size': 15})
#set lable for Y
ax.set_ylabel('user score mean')
Out[71]:
Correlation between Total sales & critic score¶
In [72]:
print(ps2_values_df.total_sales_sum.corr(ps2_values_df.critic_score_mean) )
Correlation between Total sales & user score¶
In [73]:
print(ps2_values_df.total_sales_sum.corr(ps2_values_df.user_score_mean) )
The Correlation between the users score and the sales is much stronger than between sales and critic scores¶
My conclusion is that the users scores is a good indication of future sales¶
In [ ]:
Keeping your conclusions in mind, compare the sales of the same games on other platforms.¶
Will look at games from PS2 that appear at other platforms¶
In [74]:
ps2_name_list = ps2_df.loc[:, 'name'].unique()
find games that are on PS2 and on other platforms:¶
In [ ]:
games on PS2¶
In [75]:
df_games[(df_games['name'].isin(ps2_name_list)) & (df_games['platform'] != 'PS2')].sort_values(by = 'name').head()
Out[75]:
find platforms that run PS2 games¶
In [76]:
#which plaftomrs:
platforms_list = df_games[(df_games['name'].isin(ps2_name_list)) & (df_games['platform'] != 'PS2')].sort_values(by = 'name')['platform'].unique()
find sale data of SP2 games on other platforms¶
In [77]:
df_games_other_platforms = df_games[(df_games['name'].isin(ps2_name_list)) & (df_games['platform'] != 'PS2')].pivot_table(index = ('platform', 'year_of_release'), values = ('critic_score', 'user_score', 'total_sales'), aggfunc = ('mean', 'sum')).reset_index()
In [78]:
del df_games_other_platforms[('critic_score', 'sum')]
del df_games_other_platforms[('total_sales', 'mean')]
del df_games_other_platforms[('user_score', 'sum')]
In [79]:
df_games_other_platforms.columns = ['platform', 'year_of_release', 'critic_score_mean', 'total_sales_sum', 'user_score_mean']
In [80]:
df_games_other_platforms.head()
Out[80]:
In [81]:
print('Correlation between Total sales and Critic score:')
for platform in platforms_list:
print()
print('************')
print('for platform:', platform)
df = df_games_other_platforms[df_games_other_platforms['platform'] == platform]
print(df.total_sales_sum.corr(df.critic_score_mean))
print('Correlation between Total sales and Used score:')
for platform in platforms_list:
print()
print('************')
print('for platform:', platform)
df = df_games_other_platforms[df_games_other_platforms['platform'] == platform]
print(df.total_sales_sum.corr(df.user_score_mean))
In [ ]:
In [82]:
df_games[df_games['year_of_release'] >= 2000].pivot_table(index = ('genre'), values = 'total_sales', aggfunc = 'sum' ).sort_values(by = 'total_sales')
Out[82]:
Well done!
In [ ]:
Step 4. Create a user profile for each region¶
In [ ]:
for North America market:¶
In [83]:
#find total sales by playform
sales_na_df = df_games[['platform', 'na_sales']].groupby('platform').sum().sort_values('na_sales').reset_index()
#sales_na_df
find the Z value.¶
In [84]:
sales_na_df['sales_z'] = (sales_na_df['na_sales'] - sales_na_df['na_sales'].mean()) / sales_na_df['na_sales'].std()
In [85]:
sales_na_df['colors'] = ['red' if x < 0 else 'green' for x in sales_na_df['sales_z']]
In [86]:
plt.figure(figsize = (14, 10))
#create a graph with horizontal lines
plt.hlines(y =sales_na_df.platform, xmin = 0, xmax = sales_na_df.sales_z, color = sales_na_df.colors, alpha = 0.4, linewidth = 10)
Out[86]:
In [87]:
sales_na_five_df = sales_na_df.tail().reset_index()
In [88]:
total_na = sales_na_five_df['na_sales'].sum()
sales in North America with share in market¶
In [89]:
fig, ax = plt.subplots(figsize = (8, 4))
ax.vlines(x = sales_na_five_df.platform, ymin = 0, ymax = sales_na_five_df.na_sales, color = 'purple', alpha = 0.7, linewidth = 2)
ax.scatter(x = sales_na_five_df.platform, y = sales_na_five_df.na_sales, s = 75, color = 'black', alpha = 0.7)
#set title
ax.set_title('Lollipop Chart for sales in North America with share in market', fontdict = {'size': 15})
#set lable for Y
ax.set_ylabel('sales')
#add text above the dot
for row in sales_na_five_df.itertuples():
ax.text(row.platform, row.na_sales + 30, s = str(round(row.na_sales, 2)) + ' : '+ str( round((row.na_sales / total_na) * 100, 2)) + '%')
In [ ]:
The top five platforms for North America are: X360, PS2, WII, PS3, DS.¶
In [ ]:
for Europe market:¶
In [90]:
#find total sales by playform
sales_eu_df = df_games[['platform', 'eu_sales']].groupby('platform').sum().sort_values('eu_sales').reset_index()
find the Z value.¶
In [91]:
sales_eu_df['sales_z'] = (sales_eu_df['eu_sales'] - sales_eu_df['eu_sales'].mean()) / sales_eu_df['eu_sales'].std()
In [92]:
sales_eu_df['colors'] = ['red' if x < 0 else 'green' for x in sales_eu_df['sales_z']]
In [93]:
plt.figure(figsize = (14, 10))
#create a graph with horizontal lines
plt.hlines(y =sales_eu_df.platform, xmin = 0, xmax = sales_eu_df.sales_z, color = sales_eu_df.colors, alpha = 0.4, linewidth = 10)
Out[93]:
The top five platforms for Europe are: PS2, PS3, X360, WII, PS.¶
In [ ]:
In [94]:
sales_eu_five_df = sales_eu_df.tail().reset_index()
In [95]:
total_eu = sales_eu_five_df['eu_sales'].sum()
sales in Europe with share in market¶
In [96]:
fig, ax = plt.subplots(figsize = (10, 5))
ax.vlines(x = sales_eu_five_df.platform, ymin = 0, ymax = sales_eu_five_df.eu_sales, color = 'purple', alpha = 0.7, linewidth = 2)
ax.scatter(x = sales_eu_five_df.platform, y = sales_eu_five_df.eu_sales, s = 75, color = 'black', alpha = 0.7)
#set title
ax.set_title('Lollipop Chart for sales in Europe with share in market', fontdict = {'size': 15})
#set lable for Y
ax.set_ylabel('sales')
#add text above the dot
for row in sales_eu_five_df.itertuples():
ax.text(row.platform, row.eu_sales + 30, s = str(round(row.eu_sales, 2)) + ' : '+ str( round((row.eu_sales / total_eu) * 100, 2)) + '%')
In [ ]:
for Japan market:¶
In [97]:
#find total sales by playform
sales_jp_df = df_games[['platform', 'jp_sales']].groupby('platform').sum().sort_values('jp_sales').reset_index()
find the Z value.¶
In [98]:
sales_jp_df['sales_z'] = (sales_jp_df['jp_sales'] - sales_jp_df['jp_sales'].mean()) / sales_jp_df['jp_sales'].std()
In [99]:
sales_jp_df['colors'] = ['red' if x < 0 else 'green' for x in sales_jp_df['sales_z']]
In [100]:
plt.figure(figsize = (14, 10))
#create a graph with horizontal lines
plt.hlines(y =sales_jp_df.platform, xmin = 0, xmax = sales_jp_df.sales_z, color = sales_jp_df.colors, alpha = 0.4, linewidth = 10)
Out[100]:
The top five platforms for Japan are: DS, PS, PS2, SNES, 3DS.¶
In [101]:
sales_jp_five_df = sales_jp_df.tail().reset_index()
In [102]:
total_jp = sales_jp_five_df['jp_sales'].sum()
In [ ]:
sales in Japan with share in market¶
In [103]:
fig, ax = plt.subplots(figsize = (10, 5))
ax.vlines(x = sales_jp_five_df.platform, ymin = 0, ymax = sales_jp_five_df.jp_sales, color = 'purple', alpha = 0.7, linewidth = 2)
ax.scatter(x = sales_jp_five_df.platform, y = sales_jp_five_df.jp_sales, s = 75, color = 'black', alpha = 0.7)
#set title
ax.set_title('Lollipop Chart for sales in Japan with share in market', fontdict = {'size': 15})
#set lable for Y
ax.set_ylabel('sales')
#add text above the dot
for row in sales_jp_five_df.itertuples():
ax.text(row.platform, row.jp_sales + 30, s = str(round(row.jp_sales, 2)) + ' : '+ str( round((row.jp_sales / total_jp) * 100, 2)) + '%')
The top five genres. Explain the difference.¶
for North America¶
In [104]:
genre_na_df = df_games[['genre', 'na_sales']].groupby('genre').sum().sort_values('na_sales').reset_index()
genre_na_df.tail()
Out[104]:
for Europe¶
In [105]:
genre_eu_df = df_games[['genre', 'eu_sales']].groupby('genre').sum().sort_values('eu_sales').reset_index()
genre_eu_df.tail()
Out[105]:
for Japan¶
In [106]:
genre_jp_df = df_games[['genre', 'jp_sales']].groupby('genre').sum().sort_values('jp_sales').reset_index()
genre_jp_df.tail()
Out[106]:
In [ ]:
Do ESRB ratings affect sales in individual regions?¶
In [107]:
#for North America
rating_na_df = df_games[['rating', 'na_sales']].groupby('rating').sum().sort_values('rating').reset_index()
rating_na_df.drop(rating_na_df[rating_na_df.rating == 'mis'].index, inplace=True)
In [108]:
#for Europe
rating_eu_df = df_games[['rating', 'eu_sales']].groupby('rating').sum().sort_values('rating').reset_index()
rating_eu_df.drop(rating_eu_df[rating_eu_df.rating == 'mis'].index, inplace=True)
In [109]:
#for Japan
rating_jp_df = df_games[['rating', 'jp_sales']].groupby('rating').sum().sort_values('rating').reset_index()
rating_jp_df.drop(rating_jp_df[rating_jp_df.rating == 'mis'].index, inplace=True)
In [110]:
branches = rating_jp_df['rating'].values.tolist()
na_genre_list = rating_na_df['na_sales'].values.tolist()
eu_genre_list = rating_eu_df['eu_sales'].values.tolist()
jp_genre_list = rating_jp_df['jp_sales'].values.tolist()
trace_na = go.Bar(
x = branches,
y = na_genre_list,
name = 'NA'
)
trace_eu = go.Bar(
x = branches,
y = eu_genre_list,
name = 'EU'
)
trace_jp = go.Bar(
x = branches,
y = jp_genre_list,
name = 'JP'
)
data = [trace_na, trace_eu, trace_jp]
layout = go.Layout(barmode = 'group')
fig = go.Figure(data = data, layout = layout)
iplot(fig)
The most popular rating is E (everyone) for all markets¶
In [ ]:
Step 5. Test the following hypotheses:¶
Average user ratings of the Xbox One and PC platforms are the same.¶
In [111]:
xone_user_rating = df_games[df_games['platform'] == 'XOne']['user_score']
pc_user_rating = df_games[df_games['platform'] == 'PC']['user_score']
#the significance level is 5%
alpha = 0.05
results = st.ttest_ind(xone_user_rating, pc_user_rating)
print('P-value:', results.pvalue)
if(results.pvalue < alpha):
print('We reject the null hypothesis')
else:
print('We can not reject the null hypothesis')
Average user ratings for the Action and Sports genres are different.¶
In [112]:
Action_user_rating = df_games[df_games['genre'] == 'Action']['user_score']
sport_user_rating = df_games[df_games['genre'] == 'Sports']['user_score']
#the significance level is 5%
alpha = 0.05
results = st.ttest_ind(Action_user_rating, sport_user_rating)
print('P-value:', results.pvalue)
if(results.pvalue < alpha):
print('We reject the null hypothesis')
else:
print('We can not reject the null hypothesis')
In [ ]:
How you formulated the null and alternative hypotheses¶
What significance level you chose to test the hypotheses, and why¶
For the significance level I have chosen 5% as is the standard.¶
In [ ]:
In [ ]:
In [ ]:
Step 6. Write a general conclusion¶
Conclusion:¶
My recommendations for a 2017 campaign will be:¶
To emphasize on game for the current leading platforms in sales: PS4, XOne, 3DS.¶
From the leading genres, which are: Action, Sports, Shooter.¶
The most preferred Rating is: E – everyone.¶
I would also suggest to monitor the users rating of the games.¶
In [ ]:
In [ ]:
In [ ]: